package org.ruoyi.common.chat.xunfei;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.ruoyi.common.chat.config.LocalCache;
import org.ruoyi.common.chat.holder.WebSocketSessionHolder;
import org.ruoyi.common.chat.xunfei.XunfeiWebSocketClient;
import org.ruoyi.common.core.service.ConfigService;
import org.ruoyi.common.core.utils.SpringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.AbstractWebSocketHandler;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 此文件已被弃用，请使用 XunfeiWebSocketHandler 类
 */

/**
 * 讯飞AI WebSocket处理器
 * 处理前端WebSocket连接，并将消息转发到讯飞AI
 *
 * @author ruoyi
 */
@Slf4j
@Data
public class XunfeiWebSocketHandler extends AbstractWebSocketHandler {

    /**
     * 讯飞AI WebSocket地址 (Spark Lite版本)
     */
    private static final String XUNFEI_HOST_URL_LITE = "wss://spark-api.xf-yun.com/v1.1/chat";

    /**
     * 讯飞AI WebSocket地址 (Spark Pro版本)
     */
    private static final String XUNFEI_HOST_URL_PRO = "wss://spark-api.xf-yun.com/v3.1/chat";

    /**
     * 讯飞AI WebSocket地址 (Spark Max版本)
     */
    private static final String XUNFEI_HOST_URL_MAX = "wss://spark-api.xf-yun.com/v3.5/chat";

    /**
     * 讯飞AI App ID
     */
    @Value("${xunfei.spark.app-id:}")
    private String appId;

    /**
     * 讯飞AI API Key
     */
    @Value("${xunfei.spark.api-key:}")
    private String apiKey;

    /**
     * 讯飞AI API Secret
     */
    @Value("${xunfei.spark.api-secret:}")
    private String apiSecret;

    /**
     * 讯飞AI API版本
     */
    @Value("${xunfei.spark.version:lite}")
    private String version;

    /**
     * 保存会话与讯飞AI客户端的映射关系
     */
    private final Map<String, XunfeiWebSocketClient> clientMap = new ConcurrentHashMap<>();

    /**
     * 连接成功后
     */
    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        log.info("前端WebSocket连接已建立，sessionId: {}", session.getId());
        WebSocketSessionHolder.addSession(session.getId(), session);
    }

    /**
     * 处理发送来的文本消息
     *
     * @param session WebSocket会话
     * @param message 消息内容
     */
    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        log.info("收到前端WebSocket消息: {}", message.getPayload());

        String question = "";
        JSONArray messages = null;
        try {
            // 尝试解析JSON格式的消息
            JSONObject jsonMessage = JSONUtil.parseObj(message.getPayload());
            if (jsonMessage.containsKey("question")) {
                question = jsonMessage.getStr("question");
            } else {
                // 如果不是JSON格式，直接使用原始消息内容
                question = message.getPayload();
            }
            if (jsonMessage.containsKey("messages")) {
                // 如果包含messages数组，获取最后一条用户消息作为问题
                messages = jsonMessage.getJSONArray("messages");
            }
        } catch (Exception e) {
            // JSON解析失败，直接使用原始消息内容
            log.warn("JSON解析失败，使用原始消息内容: {}", e.getMessage());
            question = message.getPayload();
        }

        // 添加调试日志，显示当前配置状态
        log.debug("当前配置信息 - AppId: {}, ApiKey: {}, ApiSecret: {}, Version: {}",
                  appId,
                  apiKey != null ? "已设置(长度:" + apiKey.length() + ")" : "null",
                  apiSecret != null ? "已设置" : "null",
                  version);

        if (StrUtil.isBlank(appId) || StrUtil.isBlank(apiKey) || StrUtil.isBlank(apiSecret)) {
            log.error("讯飞AI配置信息不完整");
            // 以JSON格式返回错误信息
            String errorMsg = "{\"code\": 500, \"content\": \"讯飞AI配置信息不完整\"}";
            session.sendMessage(new TextMessage(errorMsg));
            session.sendMessage(new TextMessage("[DONE]"));
            session.close();
            return;
        }

        try {
            // 根据配置的版本选择对应的URL
            String hostUrl = getHostUrlByVersion(version);
            log.info("使用讯飞AI接口版本: {}, 地址: {}", version, hostUrl);

            // 获取鉴权URL
            String authUrl = XunfeiWebSocketClient.getAuthUrl(hostUrl, apiKey, apiSecret);
            log.info("讯飞AI鉴权URL: {}", authUrl);

            // 检查authUrl是否为空
            if (StrUtil.isBlank(authUrl)) {
                log.error("获取讯飞AI鉴权URL失败");
                // 以JSON格式返回错误信息
                String errorMsg = "{\"code\": 500, \"message\": \"获取讯飞AI鉴权URL失败\"}";
                session.sendMessage(new TextMessage(errorMsg));
                session.sendMessage(new TextMessage("[DONE]"));
                session.close();
                return;
            }

            // 创建或获取讯飞AI WebSocket客户端
            XunfeiWebSocketClient xunfeiClient = clientMap.get(session.getId());
            if (xunfeiClient == null) {
                xunfeiClient = new XunfeiWebSocketClient(appId, apiKey, apiSecret, hostUrl, session);
                clientMap.put(session.getId(), xunfeiClient);
            }

            // 连接到讯飞AI（仅在首次建立连接时）
            if (xunfeiClient != null) {
                xunfeiClient.connect(authUrl);
            }

            // 发送消息到讯飞AI，使用解析后的问题内容和完整上下文
            xunfeiClient.sendTextToXunfei(question, messages);
        } catch (IllegalArgumentException e) {
            log.error("讯飞AI配置URL无效: {}", e.getMessage());
            // 以JSON格式返回错误信息
            String errorMsg = "{\"code\": 500, \"message\": \"讯飞AI配置URL无效: " + e.getMessage() + "\"}";
            session.sendMessage(new TextMessage(errorMsg));
            session.sendMessage(new TextMessage("[DONE]"));

        } catch (Exception e) {
            log.error("处理讯飞AI消息异常", e);
            // 以JSON格式返回错误信息
            String errorMsg = "{\"code\": 500, \"message\": \"处理讯飞AI消息异常: " + e.getMessage() + "\"}";
            session.sendMessage(new TextMessage(errorMsg));
            session.sendMessage(new TextMessage("[DONE]"));
        }
    }

    /**
     * 根据版本获取对应的host url
     *
     * @param version 版本号
     * @return 对应的host url
     */
    private String getHostUrlByVersion(String version) {
        switch (version) {
            case "pro":
                return XUNFEI_HOST_URL_PRO;
            case "max":
                return XUNFEI_HOST_URL_MAX;
            case "lite":
            default:
                return XUNFEI_HOST_URL_LITE;
        }
    }

    /**
     * 连接关闭后
     */
    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        log.info("前端WebSocket连接已关闭，sessionId: {}，状态: {}", session.getId(), status);
        WebSocketSessionHolder.removeSession(session.getId());

        // 关闭并移除讯飞AI客户端
        XunfeiWebSocketClient xunfeiClient = clientMap.get(session.getId());
        if (xunfeiClient != null) {
            xunfeiClient.close();
            clientMap.remove(session.getId());
        }
    }

    /**
     * 处理传输错误
     */
    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        log.error("WebSocket传输错误，sessionId: {}", session.getId(), exception);
        WebSocketSessionHolder.removeSession(session.getId());

        // 关闭并移除讯飞AI客户端
        XunfeiWebSocketClient xunfeiClient = clientMap.get(session.getId());
        if (xunfeiClient != null) {
            xunfeiClient.close();
            clientMap.remove(session.getId());
        }
    }
}
